Magnitudes

MAGNITUDES

“Los números son el producto de contar. Las cantidades son el producto de medir” (Gregory Bateson)

Magnitudes Físicas
En física, una cierta magnitud se expresa mediante dos datos:

La cantidad, que es un número (por ejemplo, 12.5).
La unidad, que puede ser:
1. Simple (por ejemplo metro, segundo, kilogramo, etc.).
2. Compuesta: es una expresión aritmética formada a partir de otras unidades simples (por ejemplo, m/seg²).

Un ejemplo de la magnitud compuesta aceleración es 12.5 m/seg²

En esta expresión, la cantidad y la unidad (simple o compuesta) aparecen “sueltas”, es decir, no existe una forma de expresión de la magnitud que las englobe. Aunque esto es perfectamente admisible en la vida diaria, no lo es desde un punto de vista formal ni computacional.

Este problema se agrava cuando se pretende realizar cálculos (consistentes o inconsistentes) con magnitudes, por ejemplo:

Especificación en MENTAL
Especificación de magnitudes

Una magnitud se especifica mediante la expresión cantidad*unidad. Por ejemplo,


3*metro


12*segundo


12.5*(metro÷(seg^2))

Estas expresiones tienen sentido porque:

La unidad (simple o compuesta) se autoevalúa.
La cantidad es un factor multiplicador de la unidad.

Cálculo con magnitudes

Expresadas las magnitudes de la forma descrita, es posible realizar cálculos con magnitudes, operando a la vez con cantidades y con unidades. Para ello hay que tener en cuenta las propiedades siguientes, en donde u y v representan unidades (simples o compuestas), y r1 y r2, cantidades (números reales):

Tipo de magnitudes	Operación	Propiedad
Homogéneas	Suma	`⟨( (f1u + f2u) = (f1+f2)*u )⟩`
	Resta	`⟨( (f1u − f2u) = (f1−f2)*u )⟩`
	Producto	`⟨( f1u f2u = (f1f2)*(u^2) )⟩`
	División	`⟨( f1u ÷ f2u = (f1÷f2) )⟩`
Heterogéneas	Suma	`(f1u + f2v) // se autoevalúa`
	Resta	`(f1u − f2v) // se autoevalúa`
	Producto	`⟨( f1u f2v = (f1f2)(uv) )⟩`
	División	`⟨( f1u ÷ f2v = (f1÷f2)*(u÷v) )⟩`

En el caso de cociente entre magnitudes homogéneas, se tiene una magnitud adimensional (sin unidades).

Ejemplos de operaciones con magnitudes:

(x = 5*metro) (y = 7*metro) x+y // ev. 12*metro x−y // ev. −2*metro
(x = 8*metro) x*x // ev. 64*(metro*metro) ev. 64*(metro^2)
(e = 12*metro) (t = 3*segundo) e÷t // ev. (12÷3)*(metro÷segundo) ev. 4*(metro÷segundo)
(x = 10*metro) (y = 2*metro) x÷y // ev. (10÷2)*(metro÷metro) ev. 5*1 ev. 5
(e = 8*metro) (t = 2*segundo) e+t // ev. (8*metro + 2*segundo)

Asignación de nombres a unidades compuestas

Se pueden asignar nombres a las unidades compuestas. Por ejemplo, si hacemos

( ergio =: ((cm^2)*gramo)÷(seg^2) )

entonces la expresión 123*ergio representa la expresión

123*(((cm^2)*gramo)÷(seg^2)))

Cambio de unidades

Si se quiere cambiar de unidad una cierta magnitud, basta con definir la equivalencia entre las unidades. Por ejemplo:


(x = 8*metro)


(metro = 100*cm)


x // se evalúa de forma automática como 800*cm

Si se quiere volver a expresar la magnitud en metros, hay que definir la unidad inversa:


(cm = 0.01*metro)


x  //  se evalúa otra vez como  8*metro

Especificación de magnitudes en funciones

Es posible especificar magnitudes también en funciones, tanto en los argumentos como en el resultado. Ejemplos:

Si tenemos la función seno(r*radian), r debe ser un número real que exprese un ángulo en radianes. Si queremos invocar a la función con r en grados sexagesimales, habría que hacer:

(grado = (π÷180)*radian) seno(r*grado)
Si tenemos la función atan(r)*radian, y queremos el resultad en grados, habría que hacer:

(radian = (180÷π)*grado) atan(r)*radian // el resultado es un ángulo en grados

Prefijos como conversores universales

Si tenemos los prefijos


(Kilo = 10^3)


(Mega = 10^6)


(Giga = 10^9)


(Tera = 10^12)


(mili = 10^(−3))


(micro = 10^(−6))


(nano = 10^(−9))


(pico = 10^(−12))

y hacemos, por ejemplo, ⟨( Kilo*r = (10^3)*r )⟩, estamos especificando una conversión automática para todo tipo de unidades, siempre que el prefijo tome la forma Kilo*:


73*(Kilo*m)  // ev.  73000*m


12*(Kilo*gr)  // ev.  12000*gr

Si utilizamos la sustitución potencial ⟨( Kilo*r =: (10^3)*r )⟩, entonces


73*(Kilo*m)  // rep.  73000*m


12*(Kilo*gr)  // rep.  12000*gr

Magnitudes cualitativas

Las magnitudes cualitativas son magnitudes que constituyen una cualidad o una totalidad, como verde, alto, rico, lento, verdadero, etc. Estas magnitudes pueden tener un factor entre 0 y 1, que indica el grado de dicha cualidad. Por ejemplo: 0.3*alto, 0.6*grande, etc.

También puede haber magnitudes cualitativas opuestas, relacionadas mediante factores complementarios. Por ejemplo:

El atributo alto (y su contrario bajo) puede venir afectado de un factor f (entre 0 y 1) que expresa su grado de aproximación a dicho atributo. Por ejemplo, 0.7*alto, 0.3*bajo, etc. La relación entre estos dos conceptos opuestos es:

(alto' = bajo) (bajo' = alto) ⟨( f*alto ≡ (1−f)*bajo )⟩ ⟨( (f*alto)' ≡ (1−f)*alto ≡ f*bajo )⟩ ⟨( (f*bajo)' ≡ (1−f)*bajo ≡ f*alto )⟩

En este caso, los atributos contrarios tienen factores complementarios a 1, por lo que se pueden considerar atributos complementarios.
Los valores lógicos verdadero (V) y falso (F) también se pueden tratar como magnitudes complementarias. Por ejemplo, 0.7*V indica un 70% de verdad, siendo V la “unidad” de verdad. Y 0.3*F indica un 30% de falsedad. La “cantidad” de verdad (o falsedad) es un número real entre 0 y 1, de tal manera que se cumplen propiedades similares a las anteriores:

(V' = F) (F' = V) ⟨( f*V ≡ (1−f)*F )⟩ ⟨( (f*V)' ≡ (1−f)*V ≡ f*F )⟩ ⟨( (f*F)' ≡ (1−f)*F ≡ f*V )⟩

Observaciones

Las magnitudes mejoran la comprensión, pues el nivel semántico es mayor. Los puros datos (cantidades) sin unidades suponen la semántica mínima, la asociada a los números.
Se pueden realizar cálculos con diferentes unidades en los argumentos. Ejemplos:

⟨( S(x) = x^2 )⟩ S(3*m) // ev. 9*(m^2) S(3*cm) // ev. 9*(cm^2) ⟨( S(x y) = x*y )⟩ S(3*m 4*cm) // ev. 12*(m*cm) (m = 100*cm) S(3*m 4*cm) // ev. 1200*cm
La magnitud puede aparecer en cualquier tipo de expresión. Por ejemplo,

(12*m 2*seg) (13 12 10)*(m^2) {a b}*(m¸seg)

Adenda
Unidades en lenguajes de programación

En general, los lenguajes de programación no incluyen la posibilidad de especificar unidades asociadas a valores numéricos. Uno de los pocos lenguajes que sí admiten unidades es C/ATLAS [ver Bibliografía], pero con limitaciones: solo hay un conjunto predefinido de unidades y las combinaciones entre ellas están restringidas.

De todas formas, se han hecho varias propuestas para adaptar diversos lenguajes de programación (Ada, Pascal, C++, Lisp, Standar ML, etc.) para que contemplen unidades de medida como atributos de datos [ver Bibliografía].

Cuando un lenguaje de programación no contempla unidades, su manejo en funciones y algoritmos lo tiene que realizar el programador, lo que constituye una fuente potencial de errores. Para evitar estos errores no deberían asumirse unidades por defecto, es decir, deben de especificarse de manera explícita.

Karr y Loveman [1978] has propuesto que se incorporen las unidades a los lenguajes de programación, pero como palabras reservadas, lo que constituye una limitación, limitación que no existe en MENTAL, pues:

Pueden definirse todas las unidades que se deseen.
La expresión r*unidad integra cantidad y unidad.
Pueden definirse reglas de conversión automáticas.
Los resultados de los cálculos pueden incorporar unidades.
En las funciones, los argumentos y los resultados pueden ser magnitudes.

Sistema internacional de unidades

Se basa en siete unidades fundamentales (o primitivas): metro (longitud), segundo (tiempo), Kilogramo (masa), amperio (intensidad de corriente eléctrica), grado Kelvin (temperatura), mol (cantidad de sustancia) y candela (intensidad luminosa). El resto de las unidades son derivadas, como por ejemplo, 1 Julio = 1 Kgr*m²/seg² [Anderson, 1989].

Bibliografía

Anderson, H.L. (ed.). Physicist´s Desk Reference. American Institute of Physics, 1989.
Bateson, Gregory. Number is different from Quantity. Internet.
Cunis, Roman. A Package for Handling Units of Measure in Lisp. Internet.
Gehani, N.H. Units of Measure as a Data Attribute. Computing Languages, vol. 2, no. 3, pp. 93−111, 1977.
Gehani, N.H. Databases and Units of Measure. IEEE Trans. Soft. Eng., June 1982, pp. 605−611.
Gehani, N.H. Ada´s Derived Types and Units of Measure. Software Practice and Experience, June 1985, pp. 555−569.
IEEE Standard C/ATLAS. IEEE Standar 716−1982.
Karr, M.; Loveman, D.B. Incorporation of Units into Programming Languages. Communications of the ACM, vol. 21, no. 5, pp. 385−391, May 1978.
Novak, Gordon S. (Jr.). Conversion of Units of Measurement. Internet, 1977.